﻿using System;
using System.Diagnostics;
using System.Threading;
namespace MutiThreadDebugTutorial
{

    public class ServerClass
    {
        // The method that will be called when the thread is started. 
        public void InstanceMethod()
        {
            Console.WriteLine(
                "ServerClass.InstanceMethod is running on another thread.");

            // Pause for a moment to provide a delay to make 
            // threads more apparent.
            Thread.Sleep(3000);
            Console.WriteLine(
                "The instance method called by the worker thread has ended.");
        }

        public static void StaticMethod()
        {
            Console.WriteLine(
                "ServerClass.StaticMethod is running on another thread.");

            // Pause for a moment to provide a delay to make 
            // threads more apparent.
            Thread.Sleep(5000);
            Console.WriteLine(
                "The static method called by the worker thread has ended.");
        }
    }

    // The ThreadWithState class contains the information needed for 
    // a task, the method that executes the task, and a delegate 
    // to call when the task is complete. 
    // 
    public class ThreadWithState
    {
        // State information used in the task. 
        private string boilerplate;
        private int value;

        // Delegate used to execute the callback method when the 
        // task is complete. 
        private ExampleCallback callback;

        // The constructor obtains the state information and the 
        // callback delegate. 
        public ThreadWithState(string text, int number,
            ExampleCallback callbackDelegate)
        {
            boilerplate = text;
            value = number;
            callback = callbackDelegate;
        }

        // The thread procedure performs the task, such as 
        // formatting and printing a document, and then invokes 
        // the callback delegate with the number of lines printed. 
        public void ThreadProc()
        {
            Console.WriteLine(boilerplate, value);
            if (callback != null)
                callback(1);
        }
    }

    // Delegate that defines the signature for the callback method. 
    // 
    public delegate void ExampleCallback(int lineCount);

    public class Simple
    {
        public static void Main()
        {
            Console.WriteLine("Thread Simple Sample");
            Debugger.Break();

            ServerClass serverObject = new ServerClass();

            // Create the thread object, passing in the 
            // serverObject.InstanceMethod method using a 
            // ThreadStart delegate.
            Thread InstanceCaller = new Thread(
                new ThreadStart(serverObject.InstanceMethod));

            // Start the thread.
            InstanceCaller.Start();

            Console.WriteLine("The Main() thread calls this after "
                + "starting the new InstanceCaller thread.");

            // Create the thread object, passing in the 
            // serverObject.StaticMethod method using a 
            // ThreadStart delegate.
            Thread StaticCaller = new Thread(
                new ThreadStart(ServerClass.StaticMethod));

            // Start the thread.
            StaticCaller.Start();

            Console.WriteLine("The Main() thread calls this after "
                + "starting the new StaticCaller thread.");



            // Supply the state information required by the task.
            ThreadWithState tws = new ThreadWithState(
                "This report displays the number {0}.",
                42,
                new ExampleCallback(ResultCallback)
            );

            Thread t = new Thread(new ThreadStart(tws.ThreadProc));
            t.Start();
            Console.WriteLine("Main thread does some work, then waits.");
            t.Join();
            Console.WriteLine(
                "Independent task has completed; main thread ends.");
        }

        // The callback method must match the signature of the 
        // callback delegate. 
        // 
        public static void ResultCallback(int lineCount)
        {
            Console.WriteLine(
                "Independent task printed {0} lines.", lineCount);
        }

    }
}
